import java.util.*;

public class TestDemo2 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int[][] nums = new int[num][num];
        nums[0][0] = 1;
        int ret = 1;
        if(num == 1) {
            System.out.println(1);
        }
        for (int i = 1; i < num; i++) {
            for (int j = 0; j <= i; j++) {
                if (j == 0 || j == i){
                    nums[i][j] = 1;
                }else {
                    nums[i][j] = nums[i-1][j] + nums[i-1][j-1];
                }
                ret++;
                if (nums[i][j] == num) {
                    System.out.println(ret);
                    return;
                }
            }
        }
    }


    public static void main4(String[] args) {
        Scanner in = new Scanner(System.in);
        int start = 4;
        int target = 100000;
        int[] ret = new int[target - start + 1];
        Arrays.fill(ret,Integer.MAX_VALUE);
        ret[0] = 0;
        for(int i = 0; i < ret.length; i++) {
            if(ret[ret.length - 1] < Integer.MAX_VALUE) {
                System.out.print(ret[ret.length - 1]);
                return ;
            }
            if(ret[i] == Integer.MAX_VALUE) {
                continue;
            }
            for(int j = 2; j < (i + start); j++) {
                if(i + j >= ret.length) break;

                if((i + start) % j == 0) {
                    ret[j + i] = Math.min(ret[i] + 1,ret[j + i]);
                }
            }
        }
        if(ret[ret.length - 1] == Integer.MAX_VALUE) {
            System.out.print(-1);
        }else {
            System.out.print(ret[ret.length - 1]);
        }
    }

    public static void main3(String[] args) {
        int start = 4;
        int target = 24;
        int steps = 0;
        int[] ret = new int[target + 1];
        Arrays.fill(ret,Integer.MAX_VALUE);
        ret[start] = 0;

        for(int i = start; i < target; i++) {
            for(int j = 2; j < i; j++) {
                if((i + j) <= target && i % j == 0 && ret[i] < Integer.MAX_VALUE) {
                    ret[j + i] = Math.min(ret[i] + 1,ret[j + i]);
                }
            }
        }

        System.out.print(ret[target]);
    }

    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);

//        while (in.hasNextLine()) {
            String str = in.nextLine();
            str += " ";
            int count = 0;
            // 判断参数个数
            for(int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                if(c == '"') {
                    for(int j = i+1; j <str.length(); j++) {
                        c = str.charAt(j);
                        if(c == '"') {
                            count++;
                            i = j + 1;
                            break;
                        }
                    }
                }else if(c == ' ') {
                    count++;
                }
            }
            System.out.println(count);
            String ret = "";
            for(int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                if(c == '"') {
                    for(int j = i+1; j <str.length(); j++) {
                        c = str.charAt(j);
                        if(c != '"') {
                            ret += c;
                        }else {
                            System.out.println(ret);
                            ret = "";
                            i = j + 1;
                            break;
                        }
                    }
                    continue;
                }else if(c == ' ') {
                    System.out.println(ret);
                    ret = "";
                    continue;
                }else {
                    ret += c;
                }
            }
//        }

    }

    public static int sqrt (int x) {
        if (x == 0){
            return 0;
        }
        int left = 1;
        int right = x;
        int middle = left + (right - left)/2;
        while (left < right) {
            if(middle <= x/middle && (middle+1) > x/(middle+1)) {
                return middle;
            }
            if(middle > x/middle){
                right = middle - 1;
                middle = left + (right - left)/2;
            }else{
                left = middle + 1;
                middle = left + (right - left)/2;
            }
        }
        return middle;
    }

    public String truncateSentence(String s, int k) {
        int index = 0;
        s += " ";
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == ' ' && k-- > 0){
                index = i;
            }
        }
        return s.substring(0,index);
    }

    public static int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0){
            return 0;
        }
        int newLength = 0;

        for(int i = 1;i < nums.length;i++){
            if (nums[newLength] != nums[i]){
                nums[++newLength] = nums[i];
            }
        }
        return newLength+1;
    }

    public static int removeElement(int[] nums, int val) {
        if (nums == null || nums.length == 0){
            return 0;
        }
        int newLength = 0;
        for(int i = 0;i < nums.length;i++){
            if (nums[i] != val){
                nums[newLength++] = nums[i];
            }
        }
        return newLength;
    }

    public static int romanToInt(String s) {
        HashMap<Character,Integer> map = new HashMap<>();
        map.put('I', 1);
        map.put('V', 5);
        map.put('X', 10);
        map.put('L', 50);
        map.put('C', 100);
        map.put('D', 500);
        map.put('M', 1000);
        int ans = 0;
        for (int i = 0; i < s.length(); i++) {
            if (i < s.length()-1 && map.get(s.charAt(i)) < map.get(s.charAt(i+1))){
                ans -= map.get(s.charAt(i));
            }else{
                ans += map.get(s.charAt(i));
            }
        }
        return ans;
    }

    static int sum(int n) {
        int sum = 0;
        while(n > 0)
        {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    public static boolean isHappy(int n) {
        if (n == 1){
            return true;
        }
        int fast = n;
        int slow = n;
        do{
            fast = sum(sum(fast));
            slow = sum(slow);
            if (slow == 1){
                return true;
            }
        }while(fast != slow);
        return false;
    }


    public static boolean isUgly(int n) {
        if (n == 1 || n == 2 || n == 3 || n == 5 || n == 4){
            return true;
        }
        if (n % 2 == 0){
            return isUgly(n / 2);
        }
        if (n % 3 == 0){
            return isUgly(n / 3);
        }
        if (n % 5 == 0){
            return isUgly(n / 5);
        }
        return false;
    }

    static boolean out(char c){
        System.out.print(c);
        return true;
    }
    public static void doSomething(Integer integer){
        integer=new Integer(2);
    }

    public int addDigits(int num) {
        if (num < 10){
            return num;
        }
        int ans = 0;
        while (num > 0){
            ans += num % 10;
            num /= 10;
        }
        return addDigits(ans);
    }

    public boolean CheckPermutation(String s1, String s2) {
        if (s1.length() != s2.length()) return false;
        HashMap<Character,Integer> map = new HashMap<>();
        for (int i = 0; i < s1.length(); i++) {
            char c = s1.charAt(i);
            map.put(c,map.get(c) == null ? 1 : map.get(c)+1);
        }
        for (int i = 0; i < s2.length(); i++) {
            char c = s2.charAt(i);
            map.put(c,map.get(c) == null ? 1 : map.get(c)-1);
        }

        for (int val: map.values()){
            if (val != 0){
                return false;
            }
        }
        return true;
    }

    public int countCharacters(String[] words, String chars) {
        int[] charArr = new int[26];
        for(int i=0;i<chars.length();i++){
            charArr[chars.charAt(i)-'a']++;
        }
        int ans = 0;
        for(String s : words){
            int[] temp = new int[26];
            for (int i = 0; i < s.length(); i++) {
                temp[s.charAt(i)-'a']++;
            }
            boolean flag = true;
            for (int i = 0; i < temp.length; i++) {
                if (charArr[i] < temp[i]){
                    flag = false;
                    break;
                }
            }
            if (flag){
                ans += s.length();
            }
        }
        return ans;
    }

    public int dayOfYear(String date) {
        int year = Integer.parseInt(date.substring(0, 4));
        int month = Integer.parseInt(date.substring(5, 7));
        int day = Integer.parseInt(date.substring(8));
        int days = 0;
        boolean flag = year%4==0 && year%100!=0 || year%400==0;
        switch (month-1){
            case 12:
                days += 31;
            case 11:
                days += 30;
            case 10:
                days += 31;
            case 9:
                days += 30;
            case 8:
                days += 31;
            case 7:
                days += 31;
            case 6:
                days += 30;
            case 5:
                days += 31;
            case 4:
                days += 30;
            case 3:
                days += 31;
            case 2:
                if (flag){
                    days += 29;
                }else{
                    days += 28;
                }
            case 1:
                days += 31;
        }
        days += day;
        return days;
    }

    public ListNode removeDuplicateNodes(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode cur = head;
        ListNode prev = head.next;
        HashMap<Integer,Integer> map = new HashMap<>();
        map.put(cur.val,cur.val);
        while (prev != null){
            if (map.get(prev.val) == null){
                map.put(prev.val,prev.val);
                cur.next = prev;
                cur = cur.next;
            }
            prev = prev.next;
        }
        cur.next = null;
        return head;
    }

    public ListNode removeZeroSumSublists(ListNode head) {
        if (head == null) return null;
        ListNode newNode = new ListNode(-1);
        ListNode temp = head;
        ListNode cur = newNode;
        while (temp != null){
            ListNode prev = temp;
            int sum = 0;
            while (prev != null){
                sum += prev.val;
                if (sum == 0){
                    temp.next = prev.next;
                    temp = temp.next;
                    break;
                }else{
                    prev = prev.next;
                }
            }
            if (prev == null){
                cur.next = temp;
                cur = cur.next;
                temp = temp.next;
            }
        }
        cur.next = null;
        return newNode.next;
    }


    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        if (l1 == null) return l2;
        if (l2 == null) return l1;
        ListNode cur1 = l1;
        ListNode cur2 = l2;
        ListNode newNode = new ListNode(-1);
        ListNode node = newNode;
        int add = 0;
        while (cur1 != null || cur2 != null){
            int n1 = cur1 != null ? cur1.val : 0;
            int n2 = cur2 != null ? cur2.val : 0;
            int sum = n1 + n2 + add;
            if (sum < 10){
                node.next = new ListNode(sum);
                add = 0;
            }else {
                node.next = new ListNode(sum%10);
                add = 1;
            }
            node = node.next;
            if (cur1 != null) cur1 = cur1.next;
            if (cur2 != null) cur2 = cur2.next;
        }
        if (add == 1) {
            node.next = new ListNode(1);
            node = node.next;
        }
        return newNode.next;
    }

    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode newNode = new ListNode(-1);
        newNode.next = head;
        ListNode newCur = newNode;
        ListNode cur = head;
        ListNode prev = head.next;
        while (prev != null){
            while (prev != null){
                if (prev.val >= cur.val){
                    prev = prev.next;
                    cur = cur.next;
                }else{
                    break;
                }
            }
            if (prev != null){
                while (newCur.next != null && newCur.next.val < prev.val){
                    newCur = newCur.next;
                }
                ListNode temp = newCur.next;
                cur.next = prev.next;
                newCur.next = prev;
                prev.next = temp;
            }
            prev = cur.next;
            newCur = newNode;
        }
        return newNode.next;
    }

    public ListNode sortList2(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode fast = head.next;
        ListNode slow = head;
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode newHead = slow.next;
        slow.next =null;
        ListNode leftHead = sortList2(head);
        ListNode rightHead = sortList2(newHead);

        ListNode newNode = new ListNode(-1);
        ListNode temp = newNode;
        while (leftHead != null && rightHead != null){
            if (leftHead.val <= rightHead.val){
                temp.next = leftHead;
                temp = temp.next;
                leftHead = leftHead.next;
            }else{
                temp.next = rightHead;
                temp = temp.next;
                rightHead = rightHead.next;
            }
        }
        if (leftHead == null){
            while (rightHead != null){
                temp.next = rightHead;
                temp = temp.next;
                rightHead = rightHead.next;
            }
        }
        if (rightHead == null){
            while (leftHead != null){
                temp.next = leftHead;
                temp = temp.next;
                leftHead = leftHead.next;
            }
        }
        return newNode.next;
    }

    public ListNode oddEvenList(ListNode head) {
        if (head == null || head.next == null || head.next.next == null) return head;
        ListNode oddHead = head;
        ListNode evenHead = head.next;
        ListNode evenTemp = evenHead;
        ListNode cur = evenHead.next;
        oddHead.next = null;
        evenHead.next = null;
        int count = 1;
        while (cur != null){
            if (count == 1){
                oddHead.next = cur;
                oddHead = oddHead.next;
                cur = cur.next;
                oddHead.next = null;
                count = 0;
            }
            if (count == 0){
                evenHead.next = cur;
                evenHead = evenHead.next;
                cur = cur.next;
                evenHead.next = null;
                count = 1;
            }
        }
        evenHead.next = null;
        oddHead.next = evenTemp;
        return head;
    }

    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null){
            return list2;
        }
        if (list2 == null){
            return list1;
        }

        ListNode newNode = new ListNode(-1);
        ListNode cur = newNode;
        while (list1 != null && list2 != null){
            if (list1.val <= list2.val){
                cur.next = list1;
                list1 = list1.next;
            }else{
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        if (list1 == null){
            cur.next = list2;
        }
        if (list2 == null){
            cur.next = list1;
        }
        return newNode.next;
    }

    public ListNode deleteDuplication(ListNode pHead) {
        if (pHead == null || pHead.next == null) return pHead;
        ListNode newNode = new ListNode(-1);
        newNode.next = pHead;
        ListNode temp = newNode;
        ListNode cur = pHead;
        while (cur != null && cur.next != null){
            if (cur.val == cur.next.val){
                while (cur != null && cur.next != null && cur.val == cur.next.val){
                    cur.next = cur.next.next;
                }
                cur = cur.next;
            }else{
                temp.next = cur;
                temp = temp.next;
                cur = cur.next;
            }
        }
        temp.next = cur;
        return newNode.next;
    }

    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode cur = null;
        ListNode prev = head;
        ListNode temp;
        while (prev != null){
            temp = prev.next;
            prev.next = cur;
            cur = prev;
            prev = temp;
        }
        return cur;
    }

    public ListNode detectCycle(ListNode head) {
        if (head == null || head.next == null) return null;
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow){
                break;
            }
        }
        if (fast == null || fast.next == null) return null;
        ListNode temp = head;
        while (temp != slow){
            temp = temp.next;
            slow = slow.next;
        }
        return slow;
    }

    public static void main1(String[] args) {
        System.out.println(isHappy(13));

        isUgly(0);
        System.out.println(sqrt(3));
        int[] nums = {0,0,1,1,2,3,3};
        removeDuplicates(nums);

        int[] nums2 = {0,1,2,2,3,0,4,2};
        removeElement(nums2,2);

        romanToInt("IV");
        int i = 0;
        i = ++i;
        System.out.println(i);
    }
}
